﻿#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

//struct Goods
//{
//	string _name;  // 名字
//	double _price; // 价格
//	int _evaluate; // 评价
//
//	Goods(const char* str, double price, int evaluate)
//		:_name(str)
//		, _price(price)
//		, _evaluate(evaluate)
//	{}
//	/*friend ostream& opeartor << (ostream & out, const Goods & g)
//	{
//		return os << "商品名称：" << g._name << ", 价格：" << g._price << ", 评价：" << g._evaluate;
//	}*/
//};

//int main()
//{
//	auto add = [](int x, int y)->int {return x + y; };
//	cout << add(6, 6) << endl;
//	return 0;
//}

//void Print(const vector<Goods>& v)
//{
//	for (const auto& r : v)
//	{
//		cout << "商品名称: " << r._name << ", 价格: " << r._price << ", 评价: " << r._evaluate << endl;
//	}
//}
//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
//
//	auto priceLess = [](const Goods& g1, const Goods& g2)->bool {return g1._price < g2._price; };
//	sort(v.begin(), v.end(), priceLess);
//	Print(v); cout << endl;
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
//		return g1._price > g2._price;
//		});
//	Print(v); cout << endl;
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
//		return g1._evaluate < g2._evaluate;
//		});
//	Print(v); cout << endl;
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
//		return g1._evaluate > g2._evaluate;
//		});
//	Print(v);
//}


// int main()
// {
// 	//正常交换
// 	//int x = 9, y = 0;
// 	//auto swap1 = [](int& x, int& y) {
// 	//	int tmp = x;
// 	//	x = y;
// 	//	y = tmp;
// 	//	};
// 	//swap1(x, y);
// 	//cout << x << " " << y << endl;

// 	//无法使用外部域的变量
// 	//int x = 9, y = 0;
// 	//auto swap1 = []() {
// 	//	int tmp = x;
// 	//	x = y;
// 	//	y = tmp;
// 	//	};
// 	//swap1(x, y);
// 	//cout << x << " " << y << endl;

// 	//传值捕捉也会报错
// 	//int x = 9, y = 0;
// 	//auto swap1 = [x, y](){
// 	//	int tmp = x;
// 	//	x = y;
// 	//	y = tmp;
// 	//	};
// 	//swap1();
// 	//cout << x << " " << y << endl;


// 	//可以正常捕捉了，但传值捕捉对象是外部对象的拷贝，不会修改外部变量值
// 	//int x = 9, y = 0;
// 	//auto swap1 = [x, y]() mutable{
// 	//	int tmp = x;
// 	//	x = y;
// 	//	y = tmp;
// 	//	};
// 	//swap1();
// 	//cout << x << " " << y << endl;

// 	// 引用捕捉
// 	//int x = 9, y = 0;
// 	//auto swap1 = [&x, &y](){
// 	//	int tmp = x;
// 	//	x = y;
// 	//	y = tmp;
// 	//	};
// 	//swap1();
// 	//cout << x << " " << y << endl;
// 	return 0;
// }


//int main()
//{
//	auto add = [](int x, int y) {return x + y; };
//	cout << [](int x, int y)->int {return x + y; }(1, 3) << endl;
//	cout << add(1, 3) << endl;
//	return 0;
//}

#include <thread>

//void Func(int n,int num)
//{
//	for (int i = 0; i < n; i++)
//	{
//		cout << num << ":" << i << " ";
//	}
//	cout << endl;
//}
//int main()
//{
//	thread t1(Func, 10, 1);
//	thread t2(Func, 20, 2);
//
//	t1.join();
//	t2.join();
//
//
//	return 0;
//}


//int main()
//{
//	int n1, n2;
//	cin >> n1 >> n2;
//	thread t1([n1](int num)
//		{
//			for (int i = 0; i < n1; i++)
//			{
//				cout << num << ":" << i << " " << endl;
//			}
//			cout << endl;
//		},1);
//	thread t2([n2](int num)
//		{
//			for (int i = 0; i < n2; i++)
//			{
//				cout << num << ":" << i << " " << endl;
//			}
//			cout << endl;
//		},2);
//
//	t1.join();
//	t2.join();
//
//
//	return 0;
//}


//int main()
//{
//	size_t m;
//	cin >> m;
//	vector<thread> myth(m);
//	for (size_t i = 0; i < m; i++)
//	{
//		size_t n;
//		cin >> n;
//		myth[i] = thread([i, n]()
//			{
//				for (int j = 0; j < n; j++)
//				{
//					cout << i << ":" << j << endl;
//				}
//				cout << endl;
//			});
//	}
//	for (auto& t : myth)
//	{
//		t.join();
//	}
//	return 0;
//}

//class Rate
//{
//public:
//	Rate(double rate) : _rate(rate)
//	{}
//
//	double operator()(double money, int year)
//	{
//		return money * _rate * year;
//	}
//
//private:
//	double _rate;
//};
//
//int main()
//{
//	/*int x = 0, y = 1;
//	int m = 0, n = 1;
//
//	auto swap1 = [](int& rx, int& ry)
//	{
//		int tmp = rx;
//		rx = ry;
//		ry = tmp;
//	};
//
//	cout << sizeof(swap1) << endl;*/
//
//	// 函数对象
//	double rate = 0.49;
//	Rate r1(rate);
//	r1(10000, 2);
//
//	// lambda
//	auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
//	r2(10000, 2);
//
//	auto f1 = [] {cout << "hello world" << endl; };
//	auto f2 = [] {cout << "hello world" << endl; };
//
//	//f1 = f2;
//
//	return 0;
//}
#include <list>
#include <mutex>

//mutex mtx;
//int x = 0;
//list<int> it;
//
//void Func1(int n)
//{
//	//并行
//	for (int i = 0; i < n; i++)
//	{
//		mtx.lock();
//		++x;
//		mtx.unlock();
//	}
//}
//void Func2(int n)
//{
//	//串行
//	mtx.lock();
//	for (int i = 0; i < n; i++)
//	{
//		++x;
//	}
//	mtx.unlock();
//}
//void test1()//并行测试
//{
//	size_t begin = clock();
//	thread t1(Func1, 1000000);
//	thread t2(Func1, 1000000);
//
//	t1.join();
//	t2.join();
//	size_t end = clock();
//	cout << x << endl << end - begin << endl;
//}
//void test2()//串行测试
//{
//	size_t begin = clock();
//	thread t1(Func2, 1000000);
//	thread t2(Func2, 1000000);
//
//	t1.join();
//	t2.join();
//	size_t end = clock();
//	cout << x << endl << end - begin << endl;
//}
//int main()
//{
//	//test1();
//	test2();
//	return 0;
//}


//int main()
//{
//	int n = 100000;
//	int x = 0;
//	mutex mtx;
//	size_t begin = clock();
//
//	thread t1([&, n]() {
//		mtx.lock();
//		for (int i = 0; i < n; i++)
//		{
//			++x;
//		}
//		mtx.unlock();
//		});
//
//	thread t2([&, n]() {
//		mtx.lock();
//		for (int i = 0; i < n; i++)
//		{
//			++x;
//		}
//		mtx.unlock();
//		});
//
//	t1.join();
//	t2.join();
//	size_t end = clock();
//
//	cout << x << endl;
//	cout << end - begin << endl;
//
//	return 0;
//}

//int x = 0;
//void Func(int n)
//{
//	if (n == 0) return;
//	++x;
//	Func(n - 1);
//}
//int main()
//{
//
//	return 0;
//}


//#include <thread>
//#include <mutex>
//int number = 0;
//mutex g_lock;
//int ThreadProc1()
//{
//	for (int i = 0; i < 100; i++)
//	{
//		g_lock.lock();
//		++number;
//		cout << "thread 1 :" << number << endl;
//		g_lock.unlock();
//	}
//	return 0;
//}
//int ThreadProc2()
//{
//	for (int i = 0; i < 100; i++)
//	{
//		g_lock.lock();
//		--number;
//		cout << "thread 2 :" << number << endl;
//		g_lock.unlock();
//	}
//	return 0;
//}
//int main()
//{
//	thread t1(ThreadProc1);
//	thread t2(ThreadProc2);
//	t1.join();
//	t2.join();
//	cout << "number:" << number << endl;
//	system("pause");
//	return 0;
//}

/////////////////////////////////////////////////////////////////////////////////
//review
// 
// basic function
//int main()
//{
//	int a = 1;
//	cout << [=] { return a + 1; }() << endl;
//	cout << a << endl;
//
//	cout << [&] {a += 1; return a; }() << endl;
//	cout << a << endl;//a=2
//
//	auto fun = [](int a, int b) {return a + b; };
//	int c = fun(1, 2);//c=3
//	cout << c << endl;
//
//	auto fun2 = [=, &c](int d)->int {return d += a + c; };//+5
//	cout << fun2(1) << endl;//6
//
//	return 0;
//}


#include <iostream>
#include <thread>
using namespace std;
//
//void thread_func()
//{
//	cout << "is runing..." << endl;
//}
//
//int main()
//{
//	thread t1(thread_func);
//	t1.join();
//	thread t2(move(t1));
//	if (t1.joinable())
//	{
//		cout << "active" << endl;
//	}
//	else
//	{
//		cout << "invalid" << endl;
//	}
//	t2.join();
//	return 0;
//}

//#include <iostream>
//#include <thread>
//#include <functional>
//
//void ThreadFunc1(int& x)
//{
//    x += 10;
//}
//
//void ThreadFunc2(int* x)
//{
//    (*x) += 10;
//}
//
//class MyClass
//{
//public:
//    int member_var = 10;
//
//    void MemberThreadFunc()
//    {
//        member_var += 10;
//    }
//};
//
//int main()
//{
//    int a = 10;
//
//    // 使用std::bind创建可调用对象，然后传递给std::thread
//    std::thread t1(std::bind(ThreadFunc1, std::ref(a)));
//    t1.join();
//    std::cout << "After t1 join, a = " << a << std::endl;
//
//    std::thread t2(std::bind(ThreadFunc1, std::ref(a)));
//    t2.join();
//    std::cout << "After t2 join, a = " << a << std::endl;
//
//    std::thread t3(std::bind(ThreadFunc2, &a));
//    t3.join();
//    std::cout << "After t3 join, a = " << a << std::endl;
//
//    MyClass myObj;
//    std::thread t4(std::bind(&MyClass::MemberThreadFunc, &myObj));
//    t4.join();
//    std::cout << "After t4 join, myObj.member_var = " << myObj.member_var << std::endl;
//
//    return 0;
//}

//#include <iostream>
//#include <string>
//#include <thread>
//#include <chrono>
//
//int main()
//{
//	std::string bar;
//	bar.resize(51, ' ');
//	const std::string lable{ "|/-\\" };
//	for (int i = 0; i <= 50; i++)
//	{
//		bar[i] = '#';
//		std::cout << "\r[" << bar.substr(0, i) << std::string(50 - i, ' ') << "] [" << (i * 2) << "%]" << lable[i % 4];
//		std::cout.flush();
//		std::this_thread::sleep_for(std::chrono::milliseconds(30));
//	}
//	std::cout << endl;
//}

//void print_arr2(int arr[][5], int row, int col)
//{
//    int i,j;
//    for (i = 0; i < row; i++)
//    {
//        for (j = 0; j < col; j++)
//        {
//            printf("%d ", arr[i][j]);
//        }
//        printf("\n");
//    }
//}
//
//int main()
//{
//    int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
//    print_arr2(arr, 3, 5);
//    return 0;
//}


// decltype 的应用场景
//template <class T1, class T2>
//void F(T1 t1, T2 t2)
//{
//    decltype(t1 * t2) ret; // ret 的类型由 t1 和 t2 相乘决定
//    cout << typeid(ret).name() << endl;
//}
//
//int main()  
//{
//    //const int x = 1;
//    //double y = 2.2;
//    //decltype(x * y) ret; // ret 的类型被推断为 double
//    //decltype(&x) p;      // p 的类型被推断为 int*
//
//    //cout << typeid(ret).name() << endl;
//    //cout << typeid(p).name() << endl;
//
//    //F(1, 'a'); // 根据传入参数推断 ret 的类型
//
//    const int& ra = 10;
//    int a = 10;
//    int& ral = a;
//
//    int&& r1 = 10;
//    int&& r3 = std::move(a);
//
//
//    return 0;
//}


//#include <algorithm>
//#include <string>
//
//struct Goods {
//    std::string _name;  // 商品名称
//    double _price;      // 商品价格
//    int _evaluate;     // 商品评价
//
//    Goods(const char* str, double price, int evaluate)
//        : _name(str), _price(price), _evaluate(evaluate) {}
//};
//
//// 按照价格升序比较的函数对象
//struct ComparePriceLess {
//    bool operator()(const Goods& gl, const Goods& gr) {
//        return gl._price < gr._price;
//    }
//};
//
//// 按照价格降序比较的函数对象
//struct ComparePriceGreater {
//    bool operator()(const Goods& gl, const Goods& gr) {
//        return gl._price > gr._price;
//    }
//};
//template<class T>
//void Print(const vector<T>& v)
//{
//    for (const auto& a : v)
//    {
//        cout << "商品名称：" << a._name << "，价格：" << a._price << "，评价：" << a._evaluate << endl;
//    }
//}

//int main() {
//    std::vector<Goods> v = { {"苹果", 2.1, 5}, {"香蕉", 3.0, 4}, {"橙子", 2.2, 3}, {"菠萝", 1.5, 4} };
//
//    auto p = [](const Goods& g1, const Goods& g2)->bool {return g1._price < g2._price; };
//    sort(v.begin(), v.end(), p);
//    Print(v);
//    cout<<endl;
//
//    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {return g1._price > g2._price; });
//    Print(v);
//    cout << endl;
//
//    //// 按价格升序排序
//    //std::sort(v.begin(), v.end(), ComparePriceLess());
//    //
//    //// 按价格降序排序
//    //std::sort(v.begin(), v.end(), ComparePriceGreater());
//
//
//
//    return 0;
//}


//int main()
//{
//    auto add = [](int x, int y) {return x + y; };
//    cout << add(1, 2) << endl;
//
//    cout << [](int x, int y)->int {return x + y; }(1, 3) << endl;
//
//    int a = 3, b = 4;
//    cout<<[=] {return a + b; }()<<endl;
//
//    auto func = [&](int c) {return a += c; };
//    func(1);
//    cout << a << endl;
//
//    int x = 10;
//    auto func2 = [x](int a)mutable->int {x += a; return x; };
//    cout << "x=" << func2(5) << endl;
//}